Support for clipping reads that extend past their mate #761

nh13 · 2022-01-14T06:13:43Z

Summary

This adds:

methods in SamRecordClipper to clip bases that map beyond the end of the mate for FR pairs.
Use these methods in ClipBam to implement the option --clip-bases-past-mate.
Use these method in consensus calling to properly decide the number of bases to clip based on insert size for FR pairs. This fixes a bug in the consensus caller that could improperly trim small inserts.

More details on the bug in the consensus caller that could improperly trim small inserts

If the reads are longer than the insert size, but aligned with
insertions, the consensus read may have the insertion trimmed.

See issue #759. Corrected output to include the full length read:

@HD	VN:1.6	SO:queryname	GO:none
@RG	ID:A	LB:lib1	SM:A	PL:ILLUMINA	PU:unit1
@CO	Read group A contains consensus reads generated from 1 input read groups.
lib1:8193187/A	77	*	0	0	*	*	0	0	ACCATTCTAATTACAGTGGGGGAAGTGTGCGCGCAAGTGTGTGCGTGTGTGCGCACGCGCAGGTGTGTGCGTGAGTGAAGGGATGTAGACAGAGGCTGCTGGCCGGG	CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC	cD:i:1	cE:f:0.0	RG:Z:A	MI:Z:8193187/A	cM:i:1	RX:Z:TTA-TCT	cd:B:s,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1	ce:B:s,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
lib1:8193187/A	141	*	0	0	*	*	0	0	CCCGGCCAGCAGCCTCTGTCTACATCCCTTCACTCACGCACACACCTGCGCGTGCGCACACACGCACACACTTGCGCGCACACTTCCCCCACTGTAATTAGAATGGT	CCCCCCCCCCCCCCCCCCCCC9CCC9CCC9CCCCCCCCC9CCCCCCCCCCCCCCCCCCCCCCCCCCCCC99CCCCCCC9CCCCCCCCCCCCCCCC9CCCCCCCCCCC	cD:i:1	cE:f:0.0	RG:Z:A	MI:Z:8193187/A	cM:i:1	RX:Z:TTA-TCT	cd:B:s,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1	ce:B:s,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

nh13 · 2022-01-14T06:14:18Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

-        // Adjust the insert size based on clipping on the 5' end of the given read.
-        // This *does not* consider any clipping on the 5' end of its mate.
-        val fivePrimeClipping  = cigar.takeWhile(_.operator.isClipping).filter(_.operator == CigarOperator.S).sumBy(_.length)
-        val adjustedInsertSize = abs(rec.insertSize) + fivePrimeClipping


tl;dr: using the insert size does not account for inserted bases!

nh13 · 2022-01-14T06:14:50Z

src/test/scala/com/fulcrumgenomics/umi/VanillaUmiConsensusCallerTest.scala

@@ -532,6 +532,20 @@ class VanillaUmiConsensusCallerTest extends UnitSpec with OptionValues {
    s2.cigar.toString shouldBe "46S96M"
  }

+  it should "not to trim based on insert size in the presence of soft-clipping (+/-)" in {


this is just swapping R1 and R2 from the previous test

nh13 · 2022-01-14T06:16:04Z

src/test/scala/com/fulcrumgenomics/umi/VanillaUmiConsensusCallerTest.scala

@@ -560,4 +574,18 @@ class VanillaUmiConsensusCallerTest extends UnitSpec with OptionValues {
    source.cigar.toString() shouldBe "3M"
    source.sam shouldBe Some(rec)
  }
+
+  it should "not trim reads with an insert size shorter than the read length when there's an insertion in the middle" in {


this is the new test to confirm the new behavior. Previously, the insert size would be calculated as 80bp, so the consensus read would have been 80bp. This happened because the insert size doesn't count inserted bases in the insert. The correct length of the consensus bases is 100bp.

nh13 · 2022-01-14T06:18:20Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

+        // 3' end.  If not, then we can use the full read. This *does not* consider any clipping on the 5' end of its mate.
+        val adjustedReadLength = {
+          if (rec.positiveStrand) {
+            val mateEnd = rec.mateEnd.getOrElse(rec.start + abs(rec.insertSize) - 1)


If MC isn't present, this relies on the aligner setting insert size correctly

Use CoordMath.getEnd here?

codecov-commenter · 2022-01-14T06:20:09Z

Codecov Report

Merging #761 (51b839d) into master (7512807) will decrease coverage by 0.02%.
The diff coverage is 95.06%.

@@            Coverage Diff             @@
##           master     #761      +/-   ##
==========================================
- Coverage   95.47%   95.45%   -0.03%     
==========================================
  Files         121      121              
  Lines        6855     6907      +52     
  Branches      463      479      +16     
==========================================
+ Hits         6545     6593      +48     
- Misses        310      314       +4

Flag	Coverage Δ
unittests	`95.45% <95.06%> (-0.03%)`	⬇️

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files	Coverage Δ
...c/main/scala/com/fulcrumgenomics/bam/ClipBam.scala	`96.77% <81.81%> (-2.19%)`	⬇️
...ala/com/fulcrumgenomics/bam/SamRecordClipper.scala	`97.54% <93.75%> (-0.96%)`	⬇️
...cala/com/fulcrumgenomics/alignment/Alignment.scala	`100.00% <100.00%> (ø)`
...a/com/fulcrumgenomics/umi/UmiConsensusCaller.scala	`93.98% <100.00%> (ø)`

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 7512807...51b839d. Read the comment docs.

tfenne

I think I might need to be walked through this PR. I understand the bug/goal, but have questions about the implementation.

I don't understand why the else branches are the way they are. It seems to be that they will now always remove 3' soft-clipping and I don't think that's desirable. I think there are three conceptual cases we need to walk through and make sure we agree on the expected outcome:

A read in an FR pair is aligned such that it has aligned bases that extend past the "far" end of it's mate. This is simple, we know we want to trim any bases past the mate's far end.
A read in an FR pair is aligned such that it doesn't have aligned bases that extend past the "far" end of it's mate, but is close and has soft-clipping that if converted to an M cigar, would put it past it's mate end. I'm not sure what to do in this case - the old code would have trimmed, but I'm not entirely sure that's the right thing to do.
Reads are far apart (e.g. 2x150 with 350bp insert size) but have soft-clipping at the 3' end. In this case I believe we do not want to remove the clipping.

tfenne · 2022-02-20T13:11:07Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

+        // 3' end.  If not, then we can use the full read. This *does not* consider any clipping on the 5' end of its mate.
+        val adjustedReadLength = {
+          if (rec.positiveStrand) {
+            val mateEnd = rec.mateEnd.getOrElse(rec.start + abs(rec.insertSize) - 1)


Use CoordMath.getEnd here?

tfenne · 2022-02-20T13:15:05Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

+              rec.readPosAtRefPos(pos=mateEnd, returnLastBaseIfDeleted=false)
+            } else {
+              // Find where the end of the read goes past the mate start, if at all
+              val refPosAtReadEnd  = min(mateEnd, rec.end) // last 3' base


Why is this needed? We're in an else under rec.end >= mateEnd therefore rec.end will always be <= mateEnd and therefore the value returned. Am I missing something?

tfenne · 2022-02-20T13:16:52Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

+            } else {
+              // Find where the end of the read goes past the mate start, if at all
+              val refPosAtReadEnd  = min(mateEnd, rec.end) // last 3' base
+              rec.readPosAtRefPos(pos=refPosAtReadEnd, returnLastBaseIfDeleted=false)


It's a while since I've been through this code, but this will remove any trailing clipping, insertions, and maybe deletions too. Is that intentional? I.e. if the cigar is 80M20S, say because the read runs off into a large insertion, this will return 80, and cause the read to get trimmed to 80 bases, no?

tfenne · 2022-02-20T13:20:03Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

+              rec.readPosAtRefPos(pos=refPosAtReadEnd, returnLastBaseIfDeleted=false)
+            }
+          } else {
+            // Find where the start of the read that goes before the mate start, if at all


Suggested change

// Find where the start of the read that goes before the mate start, if at all

// Find where the start of the read goes before the mate start, if at all

Just saying out loud that I find these comments hard to grok because they use start/end as then are in the SAM file, as opposed to e.g. if you're looking at reads in IGV (where directionality/strand is conveyed) I think we tend to flip start/end for reverse reads to match sequencing order.

If the reads are longer than the insert size, but aligned with insertions, the consensus read may have the insertion trimmed.

Adds methods to SamRecordClipper to clip bases that map beyond the end of the mate for FR pairs. Use these methods in ClipBam to enable the option `--clip-bases-past-mate`. Use these method in consensus calling to properly decide the number of bases to clip based on insert size for FR pairs.

nh13 · 2022-02-25T23:20:43Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

@@ -187,7 +188,7 @@ class SamRecordClipper(val mode: ClippingMode, val autoClipAttributes: Boolean)
  }

  /**
-    * Attempts to clip an additional numberOfBasesToClip from the 5' end of the read. For
+    * Attempts to clip an additional numberOfBasesToClip from the 3' end of the read. For


doc fix, unrelated but found while reading the code

nh13 · 2022-02-25T23:20:51Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

@@ -233,7 +234,7 @@ class SamRecordClipper(val mode: ClippingMode, val autoClipAttributes: Boolean)
  /**
    * Ensures that there are at least clipLength bases clipped at the 5' end
    * of the read, _including_ any existing soft and hard clipping.  Calculates any
-    * additional clipping and delegates to [com.fulcrumgenomics.bam.SamRecordClipper.[clipStartOfAlignment]].
+    * additional clipping and delegates to [[com.fulcrumgenomics.bam.SamRecordClipper.clipStartOfAlignment]].


nh13 · 2022-02-25T23:20:57Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

@@ -162,7 +163,7 @@ class SamRecordClipper(val mode: ClippingMode, val autoClipAttributes: Boolean)
      val oldElems = rec.cigar.elems.reverse
      val oldBases = rec.bases.reverse
      val oldQuals = rec.quals.reverse
-      val (newElems, readBasesClipped, refBasesClipped, bases, quals) = clip(oldElems, numberOfBasesToClip, oldBases, oldQuals)
+      val (newElems, readBasesClipped, _, bases, quals) = clip(oldElems, numberOfBasesToClip, oldBases, oldQuals)


intellij warning

nh13 · 2022-02-25T23:21:10Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

@@ -289,6 +290,96 @@ class SamRecordClipper(val mode: ClippingMode, val autoClipAttributes: Boolean)
    }
  }

+  /** Clips overlapping read pairs, where both ends of the read pair are mapped to the same chromosome, and in FR orientation.


moved from ClipBam

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

nh13 · 2022-02-25T23:22:17Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

+    *
+    * @param rec the read
+    * @param mate the mate
+    * @param doNotClip do not clip the reads, only return the number of bases that would be clipped


I could be convinced to update all the methods to have a mode where they don't actually clip, but just return how many additional bases they would clip.

nh13 · 2022-02-25T23:23:04Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

@@ -440,7 +531,7 @@ class SamRecordClipper(val mode: ClippingMode, val autoClipAttributes: Boolean)
              unreachable(s"Cigar $es doesn't contain soft clipping at the start")
          }

-          elems = newElems.result
+          elems = newElems.result()


scala warning

nh13 · 2022-02-25T23:23:35Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

@@ -168,6 +170,9 @@ trait UmiConsensusCaller[ConsensusRead <: SimpleRead] {
  /** A consensus caller used to generate consensus UMI sequences */
  private val consensusBuilder = new SimpleConsensusCaller()

+  /** Clipper utility used to _calculate_ clipping, but not do the actual clipping */
+  private val clipper = new SamRecordClipper(mode=ClippingMode.Soft, autoClipAttributes=true)


would be nice to have mode that is like "dry run", but wouldn't want that on the command line I don't think (e.g. in ClipBam). Not sure how to prevent that.

nh13 · 2022-02-25T23:24:24Z

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

-        min(adjustedInsertSize, trimToLength) - 1
+        // Get the number of mapped bases to clip that maps beyond the mate's end.  Soft-clipped bases are not counted.
+        val numBasesExtendingPasteMateEnd = this.clipper.clipExtendingPastMateEnd(rec=rec, doNotClip=true)
+        if (numBasesExtendingPasteMateEnd == 0) trimToLength - 1


this matches the previous behavior. We don't trim if only soft-clipped bases are "beyond the end of the mate"

nh13 · 2022-02-25T23:24:57Z

src/test/scala/com/fulcrumgenomics/alignment/AlignmentTest.scala

@@ -281,3 +281,23 @@ class AlignmentTest extends UnitSpec {
    alignment.subByTarget(6, 11).cigar.toString() shouldBe "5D1="
  }
 }
+
+class CigarStatsTest extends UnitSpec {


we didn't have tests for these, tsk tsk

nh13 · 2022-02-25T23:25:42Z

src/test/scala/com/fulcrumgenomics/bam/ClipBamTest.scala

@@ -524,4 +524,16 @@ class ClipBamTest extends UnitSpec with ErrorLogLevel with OptionValues {
      }
    }
  }
+
+  it should "clip FR reads that extend past the mate" in {


SamRecordClipper has nice tests, so just wrote the minimal test here to ensure it works in ClipBam.

nh13 · 2022-02-25T23:26:05Z

src/test/scala/com/fulcrumgenomics/umi/AnnotateBamWithUmisTest.scala

@@ -211,7 +211,6 @@ class AnnotateBamWithUmisTest extends UnitSpec {
    Io.writeLines(reverseFq, Io.readLines(fq).grouped(4).toSeq.reverse.flatten)
    val annotator = new AnnotateBamWithUmis(input=sam, fastq=Seq(fq, reverseFq), readStructure=Seq(ReadStructure("2M4B+M"), ReadStructure("1B+M")), output=out, attribute=umiTag, sorted=true)
    val result = intercept[Exception] { annotator.execute() }
-    println(result)


there's one, set for stun

nh13 · 2022-02-25T23:54:53Z

src/test/scala/com/fulcrumgenomics/umi/VanillaUmiConsensusCallerTest.scala

    s2.cigar.toString shouldBe "46S96M"
  }

+  it should "not trim based on insert size in the presence of soft-clipping (+/-)" in {


tests mirrors the previous one, but swaps R1 and R2

src/main/scala/com/fulcrumgenomics/alignment/Alignment.scala

tfenne · 2022-02-26T02:39:06Z

src/main/scala/com/fulcrumgenomics/bam/ClipBam.scala

+  @arg(          doc="Clip overlapping reads.", mutex=Array("clipBasesPastMate")) val clipOverlappingReads: Boolean = false,
+  @arg(          doc="Clip reads who sequence past the start of their mate.", mutex=Array("clipOverlappingReads")) val clipBasesPastMate: Boolean = false


I feel like it's awkward to make these mutex. Yes, one implies the other, but they don't contradict each other. E.g. I could totally see a pipeline that wants to always set --clip-bases-past-mate and optionally set --clip-overlapping-reads, and now it'll have to know to unset the first option based on the second, when it's not strictly necessary.

I prefer the mutex, since one is a subset of the other. If this was written from scratch, I'd prefer an enum that was "None", "PastMate", "Overlapping" for a single argument, but here we are. Perhaps we can deprecate clipOverlappingReads and make an Option[PairClipping] type, where PairClipping is PastMate or Overlapping. Does that work for you?

src/main/scala/com/fulcrumgenomics/bam/ClipBam.scala

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

src/test/scala/com/fulcrumgenomics/bam/SamRecordClipperTest.scala

tfenne · 2022-02-26T03:19:26Z

src/test/scala/com/fulcrumgenomics/bam/SamRecordClipperTest.scala

+    rec.cigar.toString shouldBe "100M"
+    mate.start shouldBe 1
+    mate.cigar.toString shouldBe "100M"
+  }


Don't you want a test with insertions in the cigar strings since that was the original bug?
Also would be nice to have tests with asymmetry - i.e. one read does extend past it's mate but the other doesn't.

Copied bug test case from here to this file.

See the test case "clip reads that where only one end extends their mate's start". Added a second one with insertions

Co-authored-by: Tim Fennell <[email protected]>

nh13

@tfenne I think this fixes up all the issues, except those that I left unresolved. I am not 100% in love with the way we trim back overlapping reads with deletions, since in some cases (see added tests) selecting a mid point in the overlapping reference window can be within the deletion, so after trimming neither read spans the deletion. For example, two fully overlapping reads that are 50M10D50M, the mid point is right in the middle of the deletion, so we'll get 50M50S for one read and 50S50M for the other. I think it's more work than I am willing to do to try to keep the deletion in one of the two reads.

src/main/scala/com/fulcrumgenomics/alignment/Alignment.scala

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

nh13 · 2022-02-26T06:56:59Z

src/main/scala/com/fulcrumgenomics/bam/SamRecordClipper.scala

+      val numBasesToClip    = if (totalClippedBases == 0) 0 else {
+        // Bases past the end, so get the additional # of bases to clip
+        val existingClippedBases = {
+          val iter = if (rec.positiveStrand) rec.cigar.reverseIterator else rec.cigar.iterator
+          iter.takeWhile(_.operator.isClipping).filter(_.operator == Op.S).sumBy(_.length)
+        }
+        Math.max(0, totalClippedBases - existingClippedBases)
+      }
+      this.clip3PrimeEndOfAlignment(rec, numBasesToClip)


Only if the read is positive strand (the record isn't assumed to be positive!). Will condition on strand and use EndOfRead or StartOfRead depending.

src/main/scala/com/fulcrumgenomics/umi/UmiConsensusCaller.scala

src/test/scala/com/fulcrumgenomics/bam/SamRecordClipperTest.scala

nh13 requested a review from tfenne January 14, 2022 06:13

nh13 commented Jan 14, 2022

View reviewed changes

nh13 assigned tfenne Jan 14, 2022

tfenne requested changes Feb 20, 2022

View reviewed changes

nh13 added 3 commits February 25, 2022 10:27

Bug fix: Consensus caller could improperly trim small inserts

7c18100

If the reads are longer than the insert size, but aligned with insertions, the consensus read may have the insertion trimmed.

fixes

c2c5aac

nh13 force-pushed the bugfix/consensus-caller-trimming branch from 388ba43 to 13d32a8 Compare February 25, 2022 23:16

nh13 changed the title ~~Bug fix: Consensus caller could improperly trim small inserts~~ Support for clipping reads that extend past their mate Feb 25, 2022

nh13 commented Feb 25, 2022

View reviewed changes

nh13 added 2 commits February 25, 2022 16:31

doc update

d6d94e2

fixup to match previous behavior

09ce36a

nh13 commented Feb 25, 2022

View reviewed changes

tfenne reviewed Feb 26, 2022

View reviewed changes

src/main/scala/com/fulcrumgenomics/alignment/Alignment.scala Outdated Show resolved Hide resolved

tfenne reviewed Feb 26, 2022

View reviewed changes

nh13 and others added 3 commits February 25, 2022 22:55

Update src/main/scala/com/fulcrumgenomics/bam/ClipBam.scala

8eceb45

Co-authored-by: Tim Fennell <[email protected]>

Apply suggestions from code review

8353d1d

Co-authored-by: Tim Fennell <[email protected]>

Review fixups

7b5b4c3

nh13 commented Feb 26, 2022

View reviewed changes

tfenne reviewed Feb 26, 2022

View reviewed changes

src/test/scala/com/fulcrumgenomics/bam/SamRecordClipperTest.scala Outdated Show resolved Hide resolved

tfenne reviewed Feb 26, 2022

View reviewed changes

src/test/scala/com/fulcrumgenomics/bam/SamRecordClipperTest.scala Outdated Show resolved Hide resolved

review fixups

51b839d

tfenne approved these changes Feb 26, 2022

View reviewed changes

nh13 unassigned tfenne Feb 28, 2022

nh13 self-assigned this Feb 28, 2022

nh13 added the 2.0 label Feb 28, 2022

tfenne assigned tfenne and nh13 and unassigned nh13 and tfenne Feb 28, 2022

nh13 merged commit d69114f into main Mar 1, 2022

nh13 deleted the bugfix/consensus-caller-trimming branch March 1, 2022 04:20

mjhipp mentioned this pull request Apr 26, 2022

CigarStats.apply could give better error if internal clipping operators found #834

Open

jrm5100 mentioned this pull request May 16, 2022

CallDuplexConsensusReads hard-clips ONE of the two duplex reads #831

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Support for clipping reads that extend past their mate #761

Support for clipping reads that extend past their mate #761

nh13 commented Jan 14, 2022 •

edited

Loading

nh13 Jan 14, 2022

nh13 Jan 14, 2022

nh13 Jan 14, 2022

nh13 Jan 14, 2022

tfenne Feb 20, 2022

codecov-commenter commented Jan 14, 2022 •

edited

Loading

tfenne left a comment

tfenne Feb 20, 2022

tfenne Feb 20, 2022

tfenne Feb 20, 2022

tfenne Feb 20, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

nh13 Feb 25, 2022

tfenne Feb 26, 2022

nh13 Feb 26, 2022 •

edited

Loading

tfenne Feb 26, 2022

nh13 Feb 26, 2022

nh13 left a comment

nh13 Feb 26, 2022

	// Find where the start of the read that goes before the mate start, if at all
	// Find where the start of the read goes before the mate start, if at all

		@arg( doc="Clip overlapping reads.", mutex=Array("clipBasesPastMate")) val clipOverlappingReads: Boolean = false,
		@arg( doc="Clip reads who sequence past the start of their mate.", mutex=Array("clipOverlappingReads")) val clipBasesPastMate: Boolean = false

Support for clipping reads that extend past their mate #761

Support for clipping reads that extend past their mate #761

Conversation

nh13 commented Jan 14, 2022 • edited Loading

Summary

More details on the bug in the consensus caller that could improperly trim small inserts

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

codecov-commenter commented Jan 14, 2022 • edited Loading

Codecov Report

tfenne left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nh13 Feb 26, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nh13 left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nh13 commented Jan 14, 2022 •

edited

Loading

codecov-commenter commented Jan 14, 2022 •

edited

Loading

nh13 Feb 26, 2022 •

edited

Loading